import { storeBindingsBehavior } from "mobx-miniprogram-bindings";
import { imStore, userStore } from "@/store/index"; // 导入IM MobX Store
import { IMessage, IPeerContact } from "@/type/index"; // 导入消息类型
import md5 from "@/util/md5.min.js"; // 导入 MD5 工具

// 获取当前用户的UID、头像、昵称，因为这些将不再是Store的固定属性
const myCurrentUid = userStore.userInfo.uid;
const myCurrentAvatar = userStore.userInfo.avatar;
Page({
  behaviors: [storeBindingsBehavior],

  data: {
    isNC: false,
    myCurrentUid,
    conversationId: "", // 当前会话ID
    peerId: "", // 聊天对方的用户ID
    peerNickname: "", // 聊天对方的昵ance
    peerAvatar: "", // 聊天对方的头像
    myAvatar: myCurrentAvatar, // 当前用户的头像，直接从缓存获取
    messageContent: "", // 输入框内容
    scrollViewToBottom: "", // 用于控制 scroll-view 滚动到指定位置 (最新消息)
    showImageActionSheet: false, // 控制图片选择操作面板的显示
    imageActions: [
      // 图片选择选项
      { name: "拍照", value: "camera" },
      { name: "从相册选择", value: "album" },
    ],
    flag: 1, // 作用不明，保持原样

    // --- 键盘与布局相关状态 ---
    keyboardHeight: 0, // 当前键盘高度

    // --- 消息操作 ActionSheet 相关状态 ---
    showMsgActionSheet: false, // 控制消息操作面板的显示
    msgActions: [] as Array<{ name: string; value: string }>, // 消息操作选项
    currentMsgIdForAction: "", // 当前进行操作的消息ID

    // --- 新增：发送频率控制状态 ---
    isSendingLocked: false, // 是否处于发送锁定状态 (冷却中)
    sendLockTimer: null as number | null, // 发送锁定的定时器ID
    sendLockCountdown: 0, // 发送锁定倒计时（用于显示）
  },

  // 绑定MobX Store
  storeBindings: {
    store: imStore,
    fields: {
      activeConversationId: () => imStore.activeConversationId, // 当前活跃会话ID
      activeConversationPeerId: () => imStore.activeConversationPeerId, // 当前活跃会话的对方ID
      activeConversationMessages: () => imStore.activeConversationMessages, // 当前活跃会话的消息列表 (computed)
      activeConversationIsBlocked: () => imStore.activeConversationIsBlocked, // 是否被拉黑
      activeConversationIsVirtual: () => imStore.activeConversationIsVirtual, // 绑定虚拟用户状态
      hasMoreMessages: () => imStore.hasMoreMessages, // 是否有更多历史消息
      isFetchingMessages: () => imStore.isFetchingMessages, // 是否正在加载消息
      peerContact: () => imStore.activeConversationPeerContact,
    },
  },
  /**
   * 新增：处理联系方式请求的响应事件 (同意/拒绝)
   */
  handleContactRequestResponse(e: WechatMiniprogram.TouchEvent) {
    const { msgId, decision } = e.currentTarget.dataset as {
      msgId: string;
      decision: "approved" | "denied";
    };

    if (!msgId || !decision) {
      console.error(
        "Missing msgId or decision in dataset",
        e.currentTarget.dataset
      );
      return;
    }

    const actionText = decision === "approved" ? "同意" : "拒绝";

    // 弹窗确认，防止误触
    wx.showModal({
      title: "确认操作",
      content: `您确定要【${actionText}】对方的请求吗？`,
      confirmText: actionText,
      confirmColor: decision === "approved" ? "#07c160" : "#ee0a24",
      success: (res) => {
        if (res.confirm) {
          // 调用 Store 中的 Action 来处理
          imStore.respondToContactRequest(msgId, decision);
        }
      },
    });
  },
  /**
   * 查看微信二维码
   */
  viewQrCode(e: WechatMiniprogram.TouchEvent) {
    const qrUrl = e.currentTarget.dataset.qr as string;
    if (qrUrl) {
      wx.previewImage({
        urls: [qrUrl],
        current: qrUrl,
      });
    }
  },
  /**
   * 复制文本到剪贴板
   */
  copyToClipboard(e: WechatMiniprogram.TouchEvent) {
    const text = e.currentTarget.dataset.text as string;
    if (text) {
      wx.setClipboardData({
        data: text,
        success: () => {
          wx.showToast({ title: "已复制", icon: "none" });
        },
      });
    }
  },
  /**
   * 拨打电话
   */
  makePhoneCall(e: WechatMiniprogram.TouchEvent) {
    const phoneNumber = e.currentTarget.dataset.phone as string;
    if (phoneNumber) {
      wx.makePhoneCall({
        phoneNumber: phoneNumber,
      });
    }
  },
  /**
   * 索取联系方式
   */
  reqMeth(e: WechatMiniprogram.TouchEvent) {
    const type = e.currentTarget.dataset.type as "phone" | "wx";
    if (!type) return;

    wx.showModal({
      title: "请求确认",
      content: `确定要向对方索取${type === "phone" ? "手机号" : "微信"}吗？`,
      success: (res) => {
        if (res.confirm) {
          imStore.reqContact(type);
        }
      },
    });
  },
  getConversationId(from_uid: string, to_uid: string): string {
    // 确保 uid 数组按字典序排序
    const uids = [from_uid, to_uid].sort().toString();
    // 计算 MD5
    return md5(uids);
  },
  clickMore() {
    this.setData({
      showMsgActionSheet: true,
      msgActions: [
        { name: "举报", value: "report" },
        { name: "拉黑", value: "blocked" },
        { name: "设置联系方式", value: "setMeth" },
      ],
    });
  },
  async onLoad(options: {
    peerId: string;
    peerNickname: string;
    peerAvatar: string;
    isBlockedByMe: string; // "true" | "false"
    isVirtualPeer: string; // "true" | "false"
    peerContact: string;
    isCon: boolean;
  }) {
    if (options.isCon) {
      this.setData({
        isNC: true,
      });
    }
    const {
      peerId,
      peerNickname,
      peerAvatar,
      isBlockedByMe,
      isVirtualPeer,
    } = options;
    let peerContactData: IPeerContact | null = null;
    try {
      // 安全地解析从 options 传来的 peerContact
      if (options.peerContact) {
        peerContactData = JSON.parse(decodeURIComponent(options.peerContact));
      }
    } catch (e) {
      console.error("Failed to parse peerContact from options:", e);
      // 如果解析失败，给一个默认值
      peerContactData = { phoneNumber: false, wx: false };
    }
    const uid = wx.getStorageSync("uid");
    const conversationId = this.getConversationId(uid, peerId);

    if (!myCurrentUid) {
      wx.showToast({ title: "用户未登录", icon: "none" });
      setTimeout(() => {
        wx.navigateBack();
      }, 1500); // 1.5秒后返回
      return;
    }

    wx.setNavigationBarTitle({
      title: decodeURIComponent(peerNickname) || "聊天",
    });

    this.setData({
      conversationId: conversationId,
      peerId: peerId,
      peerNickname: decodeURIComponent(peerNickname),
      peerAvatar: decodeURIComponent(peerAvatar),
    });
    try {
      // MobX action：设置当前活跃会话
      imStore.setActiveConversation(
        conversationId,
        peerId,
        isBlockedByMe === "true",
        isVirtualPeer === "true",
        peerContactData
      );

      if (conversationId) {
        imStore.clearConversationUnreadCount(conversationId);
        await imStore.fetchMessages(conversationId, false); // 重新拉取最新消息
      }
    } catch (error) {
      console.error(`[Page-onLoad] Failed to load chat messages:`, error);
      wx.showToast({ title: "加载消息失败", icon: "none" });
    } finally {
      wx.hideLoading();
      wx.onKeyboardHeightChange(this.onKeyboardHeightChangeCallback);
      this.scrollToBottom(); // 首次加载完成，滚动到底部
    }
  },

  onReady() {
    // 页面渲染完成后，将消息列表滚动到最底部
    this.scrollToBottom();
  },

  onShow() {
    // 页面再次显示时（例如从其他页面返回），重新拉取消息列表和清除未读数
  },

  onHide() {
    // 页面隐藏时
  },

  onUnload() {
    // 页面卸载时，清空MobX Store中的活跃会话状态
    imStore.setActiveConversation(null, null, false, null, false, null);
    // 刷新会话列表，确保会话列表中的最新消息、未读数等状态已更新
    imStore.fetchConversationList(true);
    // 解除键盘高度变化监听器
    wx.offKeyboardHeightChange(this.onKeyboardHeightChangeCallback);
    // 清除发送锁定定时器，避免内存泄漏
    if (this.data.sendLockTimer) {
      clearInterval(this.data.sendLockTimer);
      this.setData({
        sendLockTimer: null,
        isSendingLocked: false,
        sendLockCountdown: 0,
      });
    }
  },

  /**
   * 键盘高度变化回调
   * 仅用于更新 input-area-wrapper 的 bottom 属性，并滚动到底部
   */
  onKeyboardHeightChangeCallback(
    res: WechatMiniprogram.OnKeyboardHeightChangeCallbackResult
  ) {
    this.setData({
      keyboardHeight: res.height,
    });
    // 键盘弹出或收起时，确保滚动到最新消息
    this.scrollToBottom(); // 给滚动操作一个短暂的延迟，确保页面布局完成
  },

  // 消息列表滚动到顶部时触发，用于加载更多历史消息 (保持不变)
  onScrollToUpper() {
    // 只有当有更多消息且当前未在加载时才触发加载
    if (this.data.hasMoreMessages && !this.data.isFetchingMessages) {
      imStore.fetchMessages(this.data.conversationId, true); // 直接通过 imStore 实例调用 action
    }
  },

  // 滚动到消息列表底部 (保持不变)
  scrollToBottom(delay: number = 0) {
    if (delay > 0) {
      setTimeout(() => {
        wx.nextTick(() => {
          this.setData(
            {
              scrollViewToBottom: "", // 先清空，再设置，强制刷新
            },
            () => {
              this.setData({
                scrollViewToBottom: "messages-bottom-anchor",
              });
            }
          );
        });
      }, delay);
    } else {
      wx.nextTick(() => {
        this.setData(
          {
            scrollViewToBottom: "", // 先清空，再设置，强制刷新
          },
          () => {
            this.setData({
              scrollViewToBottom: "messages-bottom-anchor",
            });
          }
        );
      });
    }
  },

  // 监听输入框内容变化
  onInputChange(e: WechatMiniprogram.Input) {
    this.setData({
      messageContent: e.detail.value, // 原生 textarea 的 input 事件获取值是 e.detail.value
    });
  },

  /**
   * 辅助方法：应用发送频率锁定
   * @returns {boolean} 如果成功应用锁定（开始冷却），返回 true；如果已经处于锁定状态，返回 false。
   */
  _applySendLock(): boolean {
    if (this.data.isSendingLocked) {
      wx.showToast({
        title: `请等待${this.data.sendLockCountdown}秒后再次发送`,
        icon: "none",
        duration: 1500,
      });
      return false; // 表示未能成功应用锁定（即已处于锁定状态）
    }

    this.setData({
      isSendingLocked: true,
      sendLockCountdown: 5, // 初始倒计时
    });

    let countdown = 5;
    // 使用 setTimeout 模拟 setInterval 来避免计时器在页面隐藏时继续运行的问题，
    // 并在 onUnload 时明确清除。
    const timer = setInterval(() => {
      countdown--;
      if (countdown <= 0) {
        clearInterval(timer);
        this.setData({
          isSendingLocked: false,
          sendLockTimer: null,
          sendLockCountdown: 0,
        });
      } else {
        this.setData({
          sendLockCountdown: countdown,
        });
      }
    }, 1000);
    this.setData({ sendLockTimer: timer });
    return true; // 表示成功应用锁定
  },

  // 发送文字消息
  async sendMessage() {
    const content = this.data.messageContent.trim();
    if (!content) {
      return this.setData({
        messageContent: "",
      });
    }

    // 应用发送锁定
    if (!this._applySendLock()) {
      return; // 如果未能成功应用锁定（已锁定），则退出
    }

    // wx.requestSubscribeMessage({
    //   tmplIds: ["rJBXad410F5_6YSAsXfCe9JLIvagBYCfzYN6sqMGJTY"]
    // });

    // 调用MobX Store的发送消息 action
    await this.sendMessageWithFeedback(content, "text");
    this.setData({ messageContent: "" }); // 清空输入框
    this.scrollToBottom(); // 滚动到最新消息
  },

  // 辅助方法：封装发送消息的逻辑，包括处理图片上传 (保持不变)
  async sendMessageWithFeedback(body: string, type: IMessage["type"]) {
    try {
      // 调用 MobX Store 的 action 发送消息
      await imStore.sendMessage(this.data.peerId, body, type); // 直接通过 imStore 实例调用 action
      // UI 会响应 MobX 状态的变化
    } catch (error) {
      // 错误提示已在 store 中处理
      console.error("发送消息失败:", error);
    }
  },

  // 显示图片选择 ActionSheet
  showImageActionSheet() {
    // 在弹出选择框前，检查是否处于发送锁定状态
    if (this.data.isSendingLocked) {
      wx.showToast({
        title: `请等待${this.data.sendLockCountdown}秒后再次发送`,
        icon: "none",
        duration: 1500,
      });
      return;
    }

    this.setData({ showImageActionSheet: true });
  },

  // 关闭图片选择 ActionSheet (保持不变)
  onImageActionSheetClose() {
    this.setData({ showImageActionSheet: false });
  },

  // 选择图片方式后的处理 (拍照或从相册选择)
  async onImageActionSheetSelect(e: { detail: { value: string } }) {
    const { value } = e.detail;
    let sourceType: Array<"album" | "camera"> = [];

    if (value === "album") {
      sourceType = ["album"];
    } else if (value === "camera") {
      sourceType = ["camera"];
    }

    try {
      wx.showLoading({ title: "图片处理中...", mask: true });

      const res = await wx.chooseMedia({
        count: 1, // 只选择一张图片
        mediaType: ["image"], // 只允许选择图片
        sourceType: sourceType,
        sizeType: ["original", "compressed"], // 可以选择原图或压缩图
      });

      if (res.tempFiles && res.tempFiles.length > 0) {
        const tempFilePath = res.tempFiles[0].tempFilePath;

        // !!! 重要：这里需要调用您的图片上传接口，将本地临时路径上传到服务器
        // 并获取到服务器返回的图片可访问 URL
        // 例如： const imageUrl = await yourUploadFunction(tempFilePath);

        // **此处仅为模拟上传成功的图片URL，实际开发中请替换为真实的上传逻辑**
        const simulatedImageUrl = `https://mock-image-cdn.com/uploaded_image_${Date.now()}.jpg`; // 模拟一个图片URL
        wx.hideLoading(); // 隐藏图片处理中提示

        // 在实际发送图片消息前应用发送锁定
        if (!this._applySendLock()) {
          // 如果未能成功应用锁定（已锁定），则关闭actionSheet并退出
          this.setData({ showImageActionSheet: false });
          return;
        }

        await this.sendMessageWithFeedback(simulatedImageUrl, "image"); // 发送图片消息
        this.scrollToBottom(); // 滚动到最新消息
      } else {
        wx.hideLoading();
      }
    } catch (err) {
      wx.hideLoading();
      console.error("图片选择或上传失败:", err);
      wx.showToast({ title: "图片选择或上传失败", icon: "none" });
    } finally {
      this.setData({ showImageActionSheet: false }); // 关闭 ActionSheet
    }
  },

  // 预览图片 (保持不变)
  previewImage(e: WechatMiniprogram.TouchEvent) {
    const currentUrl = e.currentTarget.dataset.currentUrl;
    // 获取当前会话中所有已成功发送的图片消息的URL，用于图片预览
    const imageUrls = this.data.activeConversationMessages
      .filter(
        (msg: IMessage) => msg.type === "image" && msg.status === "success"
      )
      .map((msg: IMessage) => msg.body);
    wx.previewImage({
      current: currentUrl, // 当前点击的图片URL
      urls: imageUrls, // 所有可预览的图片URL列表
    });
  },

  // 显示消息操作 ActionSheet (替代 Popover)
  showRevokeActions(e: WechatMiniprogram.TouchEvent) {
    // 注意：小程序的 dataset 会将布尔值 `true` 转换为字符串 `"true"`
    const {
      msgId,
      isMyMessage,
      status,
      canRevoke,
      createTime,
    } = e.currentTarget.dataset;
    const originalCanRevoke = canRevoke; // 确保正确解析布尔值
    // 判断消息是否在5分钟内
    const fiveMinutesInMs = 5 * 60 * 1000; // 5分钟的毫秒数
    const isWithinFiveMinutes = Date.now() - createTime <= fiveMinutesInMs;
    // 只有自己的消息、处于成功状态、后端标记为可撤回 且 在5分钟内，才显示撤回选项
    if (
      isMyMessage &&
      status === "success" &&
      originalCanRevoke &&
      isWithinFiveMinutes
    ) {
      this.setData({
        showMsgActionSheet: true,
        currentMsgIdForAction: msgId,
        msgActions: [{ name: "撤回", value: "revoke" }],
      });
    }
  },

  // 消息操作 ActionSheet 关闭事件 (保持不变)
  onMsgActionSheetClose() {
    this.setData({
      showMsgActionSheet: false,
      currentMsgIdForAction: "", // 清空当前操作的消息ID
      msgActions: [], // 清空操作选项
    });
  },

  // 消息操作 ActionSheet 选中事件 (例如：选中“撤回”) (保持不变)
  onMsgActionSheetSelect(e: { detail: { value: string } }) {
    const { value } = e.detail;
    const msgId = this.data.currentMsgIdForAction; // 获取当前操作的消息ID
    const peerId = this.data.peerId;
    this.onMsgActionSheetClose(); // 选中后关闭 ActionSheet

    if (value === "revoke" && msgId) {
      wx.showModal({
        title: "撤回消息",
        content: "确定撤回这条消息吗？",
        success: async (res) => {
          if (res.confirm) {
            await imStore.revokeMessage(msgId); // 直接通过 imStore 实例调用 action
          }
        },
      });
    } else if (value === "blocked" && peerId) {
      this.handleToggleBlock();
    } else if (value === "report" && msgId) {
    }
  },

  // 可选：拉黑/解除拉黑的UI入口，通常放在页面右上角菜单中 (保持不变)
  async handleToggleBlock() {
    const peerId = this.data.peerId;
    if (!peerId) return;

    const actionText = this.data.activeConversationIsBlocked
      ? "解除拉黑"
      : "拉黑该用户";

    wx.showModal({
      title: "确认操作",
      content: `确定要${actionText}吗？`,
      success: async (res) => {
        if (res.confirm) {
          if (this.data.activeConversationIsBlocked) {
            await imStore.removeBlock(peerId); // 直接通过 imStore 实例调用 action
          } else {
            await imStore.addBlock(peerId); // 直接通过 imStore 实例调用 action
          }
        }
      },
    });
  },
});
